/**
 * 测试HTML响应处理
 * 
 * 这个脚本用于测试我们对通义千问返回的HTML格式响应的处理能力
 */
require('dotenv').config();
const fs = require('fs');
const path = require('path');

// 模拟通义千问返回的HTML响应
const htmlResponse = `<!DOCTYPE html>
<html>
<head>
  <title>通义千问响应</title>
  <meta charset="utf-8">
</head>
<body>
  <div class="response-container">
    <h1>文档分析结果</h1>
    <p>根据您提供的文档内容，我已经分析出以下结构：</p>
    
    <pre>
    [
      {
        "title": "第一章 引言",
        "startIndex": 0,
        "endIndex": 1200
      },
      {
        "title": "第二章 研究背景",
        "startIndex": 1201,
        "endIndex": 3500
      },
      {
        "title": "第三章 方法论",
        "startIndex": 3501,
        "endIndex": 6000
      }
    ]
    </pre>
    
    <p>如果您需要更详细的分析，请提供完整的文档内容。</p>
  </div>
</body>
</html>`;

// 从HTML中提取JSON的函数
function extractJSONFromHTML(html) {
  console.log('处理HTML响应...');
  
  // 1. 首先移除HTML标签，获取纯文本
  const textContent = html.replace(/<[^>]*>?/gm, '');
  console.log('提取的纯文本:', textContent.substring(0, 100) + '...');
  
  // 2. 尝试从纯文本中提取JSON
  try {
    // 查找方括号之间的内容
    const jsonMatch = textContent.match(/\[\s*\{[\s\S]*\}\s*\]/);
    if (jsonMatch) {
      const jsonStr = jsonMatch[0];
      console.log('找到可能的JSON字符串:', jsonStr.substring(0, 50) + '...');
      
      const data = JSON.parse(jsonStr);
      console.log('成功解析JSON!');
      return data;
    } else {
      console.log('未找到JSON格式的内容');
      return null;
    }
  } catch (error) {
    console.log('JSON解析失败:', error.message);
    return null;
  }
}

// 测试从HTML中提取JSON
console.log('=== 测试从HTML响应中提取JSON ===\n');
const extractedData = extractJSONFromHTML(htmlResponse);

if (extractedData) {
  console.log('✅ 成功从HTML中提取数据:');
  console.log(JSON.stringify(extractedData, null, 2));
} else {
  console.log('❌ 无法从HTML中提取有效数据');
}

// 测试从HTML中提取章节结构（不依赖JSON）
function extractChaptersFromHTML(html) {
  console.log('\n提取章节结构（不依赖JSON）...');
  
  // 移除HTML标签
  const textContent = html.replace(/<[^>]*>?/gm, '');
  
  // 使用正则表达式查找章节标题
  const chapterRegex = /(?:第[一二三四五六七八九十]+[章节])[^，。:：\n]+([:：])?[^，。\n]*/g;
  
  const chapters = [];
  let match;
  while ((match = chapterRegex.exec(textContent)) !== null) {
    chapters.push({
      title: match[0].trim(),
      startIndex: match.index,
      endIndex: match.index + 1000 // 示例值
    });
  }
  
  return chapters;
}

console.log('\n=== 测试从HTML响应中提取章节结构 ===\n');
const extractedChapters = extractChaptersFromHTML(htmlResponse);

if (extractedChapters && extractedChapters.length > 0) {
  console.log(`✅ 成功提取 ${extractedChapters.length} 个章节:`);
  console.log(JSON.stringify(extractedChapters, null, 2));
} else {
  console.log('❌ 无法提取章节结构');
}

// 测试DocumentParser._extractStructureFromText方法的逻辑
function mockExtractStructureFromText(aiText, originalContent) {
  console.log('\n模拟DocumentParser._extractStructureFromText方法...');
  
  // 检查是否为HTML格式
  if (aiText.includes('<!DOCTYPE html>') || aiText.includes('<html>') || aiText.includes('</html>')) {
    console.log('检测到HTML格式的响应，尝试提取纯文本...');
    // 简单地移除HTML标签
    aiText = aiText.replace(/<[^>]*>?/gm, '');
    console.log('提取后的纯文本前100字符:', aiText.substring(0, 100) + '...');
  }
  
  // 首先尝试从aiText中提取JSON
  try {
    const jsonMatch = aiText.match(/\[\s*\{[\s\S]*\}\s*\]/);
    if (jsonMatch) {
      const jsonStr = jsonMatch[0];
      console.log('找到可能的JSON字符串:', jsonStr.substring(0, 50) + '...');
      
      const data = JSON.parse(jsonStr);
      console.log('成功解析JSON，直接返回结构!');
      return data;
    }
  } catch (error) {
    console.log('JSON解析失败:', error.message);
  }
  
  // 如果JSON解析失败，尝试匹配常见的章节描述格式
  console.log('尝试从文本中提取章节标题...');
  const chapterRegex = /(?:第[一二三四五六七八九十百千万]+[章节]|章节\s*\d+|[0-9]+\.\s*)[^，。:：\n]+([:：])?[^，。\n]*/g;
  
  let match;
  const matches = [];
  while ((match = chapterRegex.exec(aiText)) !== null) {
    matches.push({
      title: match[0].trim(),
      index: match.index
    });
  }
  
  console.log(`找到 ${matches.length} 个章节标题`);
  
  // 模拟原始内容
  if (!originalContent) {
    originalContent = "这是第一章 引言的内容。这里是一些文本。\n\n第二章 研究背景\n这里是更多的文本。\n\n第三章 方法论\n这里是方法的描述。";
  }
  
  // 在原始内容中查找章节标题
  const structure = [];
  for (let i = 0; i < matches.length; i++) {
    const title = matches[i].title;
    
    // 使用更灵活的标题匹配逻辑
    // 提取章节标题的关键部分，如"第一章"或"引言"
    const keyPart = title.match(/第[一二三四五六七八九十]+[章节]|[0-9]+\./)?.[0] || title.substring(0, Math.min(10, title.length));
    
    console.log(`查找章节标题关键部分: "${keyPart}"`);
    const titleIndex = originalContent.indexOf(keyPart);
    
    if (titleIndex !== -1) {
      const startIndex = titleIndex;
      // 结束索引是下一章节的开始或文档结束
      let endIndex = originalContent.length;
      if (i < matches.length - 1) {
        const nextKeyPart = matches[i + 1].title.match(/第[一二三四五六七八九十]+[章节]|[0-9]+\./)?.[0] || 
                           matches[i + 1].title.substring(0, Math.min(10, matches[i + 1].title.length));
        const nextIndex = originalContent.indexOf(nextKeyPart, startIndex);
        if (nextIndex !== -1) {
          endIndex = nextIndex;
        }
      }
      
      structure.push({
        title: title,
        startIndex: startIndex,
        endIndex: endIndex > startIndex ? endIndex : originalContent.length
      });
      
      console.log(`找到章节 "${title}" 位置: ${startIndex} - ${endIndex}`);
    } else {
      console.log(`无法在原始内容中找到章节 "${title}"`);
    }
  }
  
  return structure;
}

console.log('\n=== 测试完整的结构提取逻辑 ===\n');
const mockOriginalContent = "这是第一章 引言的内容。这里是一些文本。\n\n第二章 研究背景\n这里是更多的文本。\n\n第三章 方法论\n这里是方法的描述。";
const extractedStructure = mockExtractStructureFromText(htmlResponse, mockOriginalContent);

if (extractedStructure && extractedStructure.length > 0) {
  console.log(`✅ 成功提取 ${extractedStructure.length} 个章节结构:`);
  console.log(JSON.stringify(extractedStructure, null, 2));
} else {
  console.log('❌ 无法提取完整的章节结构');
}

console.log('\n=== 测试完成 ==='); 